Label: Replace allow-none with nullable/optional

emojichooser: Plug a memory leak

Fix broken translations of 'calendar:' settings (ignored translator comments)

gsk: Fix a prefix mishap

There shouldn't be any gst_ functions in here...

Cosmetics

Go back to a single GskVulkanOpRender that can
handle 0, 1 or 2 sources.

vulkan: Implement nonseparable blendmodes

This is a directly-from-the-spec, unoptimized implementation.

vulkan: Implement blend modes

This is another example for a 2-texture shader.
So far, only separable blend modes are implemented.
The implementation is not optimized, with an
if-else cascade in the shader.

vulkan: fix a clip handling problem

We were looking at uninitialized memory here, instead
of the type of the source clip, as we should.

This showed up as mispositioned clip in the first frame
of a crossfade stack transition, and also as overdraw in
sliding stack transitions.

vulkan: Implement crossfade

This is the first shader using two textures. It almost works.

vulkan: Drop GskVulkanPipelineLayout

We already move the descriptor set layout out of it,
so we can just as well keep the pipeline layouts in
the render object as well, and get rid of this extra
object. Update all callers.

Allow different pipeline layouts

These are differentiated by the number of textures; currently
we have shaders with 0 and 1 textures.

Add a getter to the pipeline layout directly from the pipeline

This is a step towards allowing multiple pipeline layouts.

vulkan: Move descriptor set layout to the render object

We want to maintain a single descriptor set layout while introducing
multiple pipeline layouts, so split this off.

Update Persian translations

gdk: Add g-i annotations for new event getters

Fix a typo

Drop gail-4.0.pc.in

libgail is gone.

gsk: vulkan: Drop an unused api

We don't use the upload-single-region api anymore.
No need to keep it around.

vulkan: Batch uploads from the glyph cache

This uses the new api that was introduced in the previous
commit.

vulkan: Add an api to update multiple image regions

Instead of doing multiple copy commands with a tiny buffer
for each glyph, we can just batch them all together. This
also avoids the issue of creating multiple barriers for the
same image.

vulkan: Quiet another validation warning

It complains if a vertex shader has an out that is not matched
to an in of the fragment shader.

vulkan: Quiet another validation error

Cosmetic change

gsk: Make repeat nodes deserializable

This was just a simple oversight.

gsk: Fix serialization of text nodes

Add simple aging for the glyph cache

This should prevent the cache from growing out of bounds.

gsk vulkan: Use new api in the glyph cache

Use the newly introduced gsk_vulkan_image_new_for_atlas.

gsk: vulkan: rework image layout/access transitions

By tracking the last transition we can build the appropriate barriers.
Also use the most appropriate initial layout/access at creation :

for linear image : predefined (we prepare the content ourself through memcpy)
for everything else : undefined (we don't care about the content, will most likely be erase)

gsk: vulkan: silence anisotropy validation warning

glyph cache: Upload glyphs incrementally

This does not work yet.

vulkan: pass the context when creating a glyph cache

vulkan: Add an upload_region api to GskVulkanImage

This will let us update larger textures incrementally.
Sadly, it does not work yet.

Add some debug output for the glyph cache

Print out some statistics and dump the glyph caches to a png,
for now.

Make the glyph cache grow as needed

Make it possible to have more than one texture in the
glyph cache, and create new ones when we run out of space
in the existing ones.

vulkan: Move glyph cache to a separate file

Otherwise things will get too messy.

vulkan: Better glyph cache api

Move the glyph caching api to something that can support using
multiple textures. We now split the text render ops into multiple
ops for different textures, and make each op render just a substring
of the text node's glyph string.

ToolItem: Fix nullable annotation put on wrong arg

D’oh

gdkseatdefault: Grab touch events where applicable

gdk_seat_default_grab() grabs POINTER_EVENTS if the capability is
GDK_SEAT_CAPABILITY_ALL_POINTING. But that enumerator is a union that
includes GDK_SEAT_CAPABILITY_TOUCH, but we never grabbed TOUCH_EVENTS,
an unused macro that was presumably created with this purpose in mind.

So, check which of the ALL_POINTING capabilities we have, and set the
right mask of POINTER_EVENTS and/or TOUCH_EVENTS as required.

As part of this, explicitly let TABLET_STYLUS take over pointer events,
as this is the intended behaviour and was the effective result before.

This should fix touch events being lost in migrating from Device.grab()
to Seat.grab(GDK_SEAT_CAPABILITY_ALL_POINTING), as found by Inkscape.

https://bugzilla.gnome.org/show_bug.cgi?id=781757

Overlay: Document style classes added per position

Update POTFILES.in

gtkmain: Ensure to emit real GDK_LEAVE_NOTIFY events.

If we got a GDK_LEAVE_NOTIFY event from GDK, we would reset the
GtkPointerFocus, but the event would be silently consumed.

gdk/x11: Implement GDK_CROSSING_TOUCH_BEGIN/END/DEVICE_CHANGE events

The behavior where a touchpoint takes over the pointer position is
really backend dependent. Since this went away from the generic code,
implement it here.

gdk: Remove remainings of fake crossing event delivery across touch

This was by all lights broken, and is basically an implementation detail
of the X11 backend since the pointer emulating touch just steals the pointer
cursor, so should be reimplemented there.

gdk: Coalesce 2 GdkWindow fields in GdkPointerWindowInfo struct

One used to point to the toplevel and the other to the client-side window
that the pointer pointed to. The latter was made to be like the former in
most places, so put those together, and fix the remaining cases where the
variable might not end up with a toplevel/native window.

gdk: Remove unused variable

It was supporting API that has been removed.

gdk: Remove implicit touch grab accounting

This is not necessary now that there's no client-side windows to track.
The only removed piece that could make sense is emission of grab broken
events, but it's already an stretch since the semantics of those with
multi-touchpoint is unclear.

Anyhow, This should be fixed at the GTK level, while we let GDK deal with
seat/device level grabs.

gdk: Remove motion hints

Motion hints are now literally a thing of the past. Everything should be
using the full motion event stream.

gdk: Drop generation of synthesized crossing events on grabs

GDK just needs to care about toplevels nowadays, which means these events
are already delivered from the windowing. We don't need to generate
intra-window crossing events ourselves.

gtk: Remove 2BUTTON and 3BUTTON events and event types

Those should be interpreted by widget-local gestures, not guessed at a
high level with no notions of the specific context. Users will want
GtkGestureMultiPress to replace these events.

gdk: Remove array of event masks

This has been unused since all events are just forwarded instead of
checking client-side windows evmasks.

gtklistbox: Remove enter/leave/motion event handlers

Those worked similarly to those in GtkFlowBox, but would additionally
handle "active" state for child rows. Simplify this to just enabling/
disabling active state on gesture press/release, we don't get the
nice state updates when hovering around with a mouse button pressed,
but the rationale from flowbox applies here, and makes a nice cleanup.

gtkcolorswatch: Remove enter/leave event handlers

Those just maintained prelight state, which is already managed internally.

gtkbutton: Remove enter/leave event handlers

They just maintain priv->in_button and widget state up-to-date, this
basically matters during user interaction, and is already maintained
in the gesture ::update handler. This seems to be sufficient.

gtkflowbox: Drop crossing/motion event handlers

Those basically controlled priv->active_child_active, which would
1) trigger a redraw when the pointer enters/leaves it, and 2) ensure
that press/release happen on the same child for it to be activated.

The former is not necessary, and the latter can be simplified by
just checking again the child on the coordinates given by the
::release gesture handler. This makes all enter/leave/motion_notify
event handlers unneeded.

gtkspinbutton: Remove motion notify handler

It does nothing nowadays.

gtkcalendar: Use scroll event controller

gtkscrolledwindow: Use scroll event controller

All kinetic scrolling initial velocity calculations are now
taken from the scroll controller. The handling of timeouts
to snap back when overshooting has been also made to just
apply on devices that can't emit ::scroll-begin/end.

gtkspinbutton: Use scroll event controller

gtkscalebutton: Use scroll event controller

gtkrange: Use scroll event controller

gtkpathbar: Use scroll event controller

gtkmenu: Use scroll event controller

gtkcombobox: Use scroll event controller

gtk: Add GtkEventControllerScroll

This is a GtkEventController implementation to handle mouse
scrolling. It handles both smooth and discrete events and
offers a way for callers to tell their preference too, so
smooth events shall be accumulated and coalesced on request.

On capable devices, it can also emit ::scroll-begin and
::scroll-end enclosing all ::scroll events for a scroll
operation.

It also has builtin kinetic scrolling capabilities, reporting
the initial velocity for both axes after ::scroll-end if
requested.

gdk/x11: Avoid delivering emulated scroll events

We now just propagate the real event, and let the caller deal
with smooth vs discrete.

gdk/wayland: Drop emission of emulated scroll events

A wl_pointer.frame can now only result on one scroll event
being emitted.

gtk: Change gtk_propagate_event() to propagate both ways.

This change is made for consistency, it doesn't make sense to expose
one-way propagation, as it can only break expectations from GTK+. This
function might be made entirely private in the future, but it still
makes sense to do this in one go for our internal usecases.

gdk/x11: Drop motion/button events emulated from touch

We now always listen to touch events. Just avoid delivering both
types of events.

eventcontroller: Drop event_mask API

This is unchecked, we can remove it entirely as well.

gtkwidget: Drop pointer emulation out of touch events

Users of touch events are required to either use a GtkGesture, or handle
touch events themselves.

gtk: Run GtkWidgetClass event signals inside a GtkEventController

This will allow further cleanups and optimizations in capture/target/bubble
event delivery. For simplicity, ATM every widget will receive its own
GtkEventControllerLegacy, it could be desirable to add finer control over
this in the future, so widgets that fully use event controllers for input
management can do away without this legacy piece.

testsuite: Use GdkEvent API

tests: Use GdkEvent API

examples: Use GdkEvent API

widget: Give up on GdkEvent api for now

treeview: Give up on GdkEvent api for now

There's multiple places where events are manually generated
here, this needs more thought.

entry accessible: Give up on GdkEvent api for now

Just include gdkeventsprivate.h here for now. This may be
resolved by just dropping icon support from GtkEntry down
the road.

a11y: Stop listening for configure events

This needs to be done differently.

Add some more GdkEvent getters

gtk-demo: Use GdkEvent API

treev view column: Use GdkEvent API

clipboard: Use GdkEvent API

a11y: Use GdkEvent API in some places

More work needed.

tooltip: Use GdkEvent API

And at the same time, reshuffle things slightly to avoid
creating synthetic events.

text view: Use GdkEvent API

text handle: Use GdkEvent API

selection: Use GdkEvent API

search bar: Use GdkEvent API

scrolled window: Use GdkEvent API

places view: Use GdkEvent API

place sidebar: Use GdkEvent API

path bar: Use GdkEvent API

pad controller: Use GdkEvent API

menu shell: Use GdkEvent API

menu item: Use GdkEvent API

im context simple: Use GdkEvent API

header bar: Use GdkEvent API

gesture zoom: Use GdkEvent API

gesture swipe: Use GdkEvent API

gesture single: Use GdkEvent API